home *** CD-ROM | disk | FTP | other *** search
/ TOS Silver 2000 / TOS Silver 2000.iso / programm / AGNUS / SRC / USAGE / USAGE.C < prev   
Encoding:
C/C++ Source or Header  |  1998-03-01  |  6.6 KB  |  287 lines
  1. /*
  2.  *    Usage (kleiner Systemlastmonitor)
  3.  *    by Albertus Grunwald
  4.  *    (c) MAXON Computer 1993
  5.  *    siehe STC 6/93
  6.  *  mit Verbesserungen von Volker Hemsen
  7.  *    Compiler: GNU C
  8.  *    Libs: aes, vdi, std, xlb
  9.  */
  10.  
  11. #include <stddef.h>
  12. #include <string.h>
  13. #include <time.h>
  14. #include <aesbind.h>
  15. #include <vdibind.h>
  16. #include <mintbind.h>
  17. #include <xlb.h>
  18.  
  19. #define SIZEW 120
  20. #define SIZEH 75
  21. #define W_KIND (NAME|CLOSE|MOVE)
  22.  
  23. extern short _app;
  24. extern unsigned short    _global[];
  25. # define IS_APP    (_app!=0)
  26. # define IS_ACC (_app==0)
  27.  
  28. int iVDIHandle,iWindHandle=0;
  29. GRECT RectDesk,RectWind;
  30. int piEventUsage[SIZEW],iEventCurrent;
  31. int piMemoryUsage[SIZEW],iMemoryCurrent;
  32. int piEventXY[SIZEW*2],piMemoryXY[SIZEW*2];
  33. int iTextHeight;
  34.  
  35. long get_long(long *aptr);
  36. long RAMmax(void);
  37. long RAMfree(void);
  38. boolean WindOpen(void);
  39. void WindClose(void);
  40. void WindRawRedraw(GRECT*);
  41. void WindRedraw(GRECT*);
  42. void Event(void);
  43.  
  44. long get_long(long *aptr)
  45. {
  46.     static long lpeek(void)
  47.     {
  48.         return *aptr;
  49.     }
  50.     return Supexec(lpeek);
  51. }
  52.  
  53. #define PHYSTOP        ((long*)0x042E)
  54. #define RAMVALID    ((long*)0x05A8)
  55. #define RAMTOP        ((long*)0x05A4)
  56.  
  57. long RAMmax(void)
  58. {
  59.     register long lmax=get_long(PHYSTOP);
  60.     if (get_long(RAMVALID)==0x1357bd13) {
  61.         register long l=get_long(RAMTOP)-(1L<<24);
  62.         if (l>0)
  63.             lmax+=l;
  64.     }
  65.     return lmax;
  66. }
  67.  
  68. long RAMfree(void)
  69. {
  70.     register long lfree;
  71.     if (Sversion()>=0x1900)
  72.         lfree=(long)Mxalloc(-1L,0)+(long)Mxalloc(-1L,1);
  73.     else
  74.         lfree=(long)Malloc(-1L);
  75.     return lfree;
  76. }
  77.  
  78. boolean WindOpen(void)
  79. {
  80.     if (iWindHandle<=0) {
  81.         iWindHandle=wind_gcreate(W_KIND,&RectDesk);
  82.         if (iWindHandle<0) {
  83.             form_alert(1,"[3][No more|windows! ][  OK  ]");
  84.             return FALSE;
  85.         } else {
  86.             wind_title(iWindHandle," Usage-Mon ");
  87.             wind_gopen(iWindHandle,&RectWind);
  88.             wind_gget(iWindHandle,WF_WORKXYWH,&RectWind);
  89.         }
  90.     } else
  91.         wind_set(iWindHandle,WF_TOP);
  92.     return TRUE;
  93. }
  94.  
  95. void WindClose(void)
  96. {
  97.     if (iWindHandle>0) {
  98.         wind_gget(iWindHandle,WF_CURRXYWH,&RectWind);
  99.         wind_close(iWindHandle);
  100.         wind_delete(iWindHandle);
  101.         iWindHandle=0;
  102.     }
  103. }
  104.  
  105. void WindRawRedraw(GRECT *pRect)
  106. {
  107.     char s[14];
  108.     int xx=RectWind.g_x+1,yy=RectWind.g_y+1;
  109.     void CurrentText(char* sName,int iColor,int iValue)
  110.     {
  111.         register char* ps;
  112.         strcpy(s,sName);
  113.         strcat(s,": ");
  114.         ps=&s[strlen(s)];
  115.         *ps++='0'+(iValue/10);
  116.         *ps++='0'+(iValue%10);
  117.         *ps++='%';
  118.         *ps=0;
  119.         vst_color(iVDIHandle,iColor);
  120.         v_gtext(iVDIHandle,xx,yy,s);
  121.         yy+=iTextHeight;
  122.     }
  123.     pRect->g_w+=pRect->g_x-1;
  124.     pRect->g_h+=pRect->g_y-1;
  125.     vs_clip(iVDIHandle,1,(int*)pRect);
  126.     vr_recfl(iVDIHandle,(int*)pRect);
  127.     vsl_color(iVDIHandle,V_BLUE);
  128.     v_pline(iVDIHandle,SIZEW,piEventXY);
  129.     vsl_color(iVDIHandle,V_RED);
  130.     v_pline(iVDIHandle,SIZEW,piMemoryXY);
  131.     CurrentText("EVENTS",V_BLUE,iEventCurrent);
  132.     CurrentText("MEMORY",V_RED,iMemoryCurrent);
  133.     vs_clipoff(iVDIHandle);
  134. }
  135.  
  136. void WindRedraw(GRECT* pRectWind1)
  137. {
  138.     if (iWindHandle>0) {
  139.         GRECT RectWind1,RectWind2;
  140.         {
  141.             register int ii,jj;
  142.             register int xx=RectWind.g_x,yy=RectWind.g_y+RectWind.g_h-1;
  143.             for(ii=0,jj=0;ii<SIZEW;ii++) {
  144.                 piEventXY[jj]=piMemoryXY[jj]=xx+ii;
  145.                 jj++;
  146.                 piEventXY[jj]=yy-piEventUsage[ii];
  147.                 piMemoryXY[jj]=yy-piMemoryUsage[ii];
  148.                 jj++;
  149.             }
  150.         }
  151.         begin_update();
  152.         RectWind1=*pRectWind1;
  153.         if (rc_intersect(&RectWind,&RectWind1)) {
  154.             if (rc_intersect(&RectDesk,&RectWind1)) {
  155.                 boolean bMouseIn;
  156.                 bMouseIn=hide_mouse_inside(&RectWind1);
  157.                 wind_gget(iWindHandle,WF_FIRSTXYWH,&RectWind2);
  158.                 while ((RectWind2.g_w) && (RectWind2.g_h)) {
  159.                     if (rc_intersect(&RectWind1,&RectWind2))
  160.                         WindRawRedraw(&RectWind2);
  161.                     wind_gget(iWindHandle,WF_NEXTXYWH,&RectWind2);
  162.                 }
  163.                 if (bMouseIn)
  164.                     show_mouse();
  165.             }
  166.         }
  167.         end_update();
  168.     }
  169. }
  170.  
  171.  
  172. void Event(void)
  173. {
  174.     boolean bQuit=FALSE;
  175.     long lMemoryMax=RAMmax();
  176.     long ltc=0,ltmax=0;
  177.     time_t told=time(NULL);
  178.     MEVENT event;
  179.     event.flags=(MU_MESAG|MU_TIMER);
  180.     event.time=(IS_APP)?0:50;
  181.     while (!bQuit) {
  182.         register short* pmsg=event.msg,iev;
  183.         iev=evnt_event(&event);
  184.         if (iev&MU_MESAG) {
  185.             begin_update();
  186.             switch(pmsg[0]) {
  187.                 case AC_OPEN:
  188.                     WindOpen();
  189.                     break;
  190.                 case AC_CLOSE:
  191.                     WindClose();
  192.                     break;
  193.                 case AP_TERM:
  194.                     bQuit=TRUE;
  195.                     break;
  196.                 default:
  197.                     if (pmsg[3]==iWindHandle) {
  198.                         switch(pmsg[0]) {
  199.                             case WM_REDRAW:
  200.                                 WindRedraw((GRECT*)&pmsg[4]);
  201.                                 break;
  202.                             case WM_MOVED:
  203.                                 wind_gset(iWindHandle,WF_CURRXYWH,(GRECT*)&pmsg[4]);
  204.                                 wind_gget(iWindHandle,WF_WORKXYWH,&RectWind);
  205.                                 break;
  206.                             case WM_TOPPED:
  207.                                 wind_set(iWindHandle,WF_TOP,iWindHandle);
  208.                                 break;
  209.                             case WM_CLOSED:
  210.                                 WindClose();
  211.                                 if (IS_APP)
  212.                                     bQuit=TRUE;
  213.                                 break;
  214.                         }    /* switch 2 */
  215.                     }    /* if handle */
  216.             }    /* switch 1 */
  217.             end_update();
  218.         }    /* if message */
  219.         if (iev&MU_TIMER) {
  220.             time_t tdelta,tnew=time(NULL);
  221.             ltc++;
  222.             if (tnew!=told) {
  223.                 register int jj;
  224.                 tdelta=(tnew-told)/2;
  225.                 if (ltmax<ltc)
  226.                     ltmax=ltc;
  227.                 for(jj=0;jj<tdelta;jj++) {
  228.                     register long lMemoryFree;
  229.                     memcpy((void*)piEventUsage,(void*)&piEventUsage[1],sizeof(int)*(SIZEW-1));
  230.                     piEventUsage[SIZEW-1]=(int)(((ltmax-ltc)*RectWind.g_h)/ltmax);
  231.                     iEventCurrent=(int)(((ltmax-ltc)*100)/ltmax);
  232.                     memcpy((void*)piMemoryUsage,(void*)&piMemoryUsage[1],sizeof(int)*(SIZEW-1));
  233.                     lMemoryFree=RAMfree();
  234.                     piMemoryUsage[SIZEW-1]=(int)(((lMemoryMax-lMemoryFree)*RectWind.g_h)/lMemoryMax);
  235.                     iMemoryCurrent=(int)(((lMemoryMax-lMemoryFree)*100L)/lMemoryMax);
  236.                 }
  237.                 ltc=0;
  238.                 told=tnew;
  239.                 WindRedraw(&RectWind);
  240.             }
  241.         }    /* if timer */
  242.     }
  243. }
  244.  
  245.  
  246. int main(void)
  247. {
  248.     int iApId,d,iReturn=0;
  249.     iApId=appl_init();
  250.     if (iApId<0) {
  251.         /*form_alert(1,"[3][Applikation kann nicht|angemeldet werden.][  OK  ]");*/
  252.         return(100);
  253.     }
  254.     {
  255.         register short apc=_global[1];
  256.         if ((apc<=0) || (apc>1) || (IS_ACC))
  257.             menu_register(iApId,"  Usage-Monitor");
  258.     }
  259.     begin_update();
  260.     iVDIHandle=v_opnvwk_screen();
  261.     if (iVDIHandle<=0)
  262.         iReturn=102;
  263.     if (iReturn==0) {
  264.         vsf_color(iVDIHandle,V_WHITE);
  265.         vst_height(iVDIHandle,4,&d,&d,&iTextHeight,&d);
  266.         vst_align(iVDIHandle,0,5);
  267.         wind_gget(0,WF_WORKXYWH,&RectDesk);
  268.         xywh_to_grect(0,0,SIZEW,SIZEH,&RectWind);
  269.         wind_gcalc(WC_BORDER,W_KIND,&RectWind,&RectWind);
  270.         RectWind.g_x+=RectDesk.g_x+RectDesk.g_w-RectWind.g_w-4;
  271.         RectWind.g_y=RectDesk.g_y+3;
  272.         if (IS_APP) {
  273.             arrow_mouse();
  274.             if (WindOpen()==FALSE)
  275.                 iReturn=101;
  276.         }
  277.         end_update();
  278.         if (iReturn==0)
  279.             Event();
  280.         WindClose();
  281.         v_clsvwk(iVDIHandle);
  282.     } else
  283.         end_update();
  284.     appl_exit();
  285.     return iReturn;
  286. }
  287.